home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / shells / bashsrc.zoo / copy_cmd.c < prev    next >
C/C++ Source or Header  |  1991-06-05  |  7KB  |  256 lines
  1. /* copy_command.c -- copy a COMMAND structure.  This is needed
  2.    primarily for making function definitions, but I'm not sure
  3.    that anyone else will need it.  */
  4.  
  5. /* Copyright (C) 1989 Free Software Foundation, Inc.
  6.  
  7.    This file is part of GNU Bash, the Bourne Again SHell.
  8.  
  9.    Bash is free software; you can redistribute it and/or modify it under
  10.    the terms of the GNU General Public License as published by the Free
  11.    Software Foundation; either version 1, or (at your option) any later
  12.    version.
  13.  
  14.    Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  15.    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16.    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17.    for more details.
  18.  
  19.    You should have received a copy of the GNU General Public License along
  20.    with Bash; see the file COPYING.  If not, write to the Free Software
  21.    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  22.  
  23. #include <stdio.h>
  24. #include "shell.h"
  25.  
  26. /* Forward declaration. */
  27. extern COMMAND *copy_command ();
  28.  
  29. WORD_DESC *
  30. copy_word (word)
  31.      WORD_DESC *word;
  32. {
  33.   WORD_DESC *new_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
  34.   bcopy (word, new_word, sizeof (WORD_DESC));
  35.   new_word->word = savestring (word->word);
  36.   return (new_word);
  37. }
  38.  
  39. /* Copy the chain of words in LIST.  Return a pointer to 
  40.    the new chain. */
  41. WORD_LIST *
  42. copy_word_list (list)
  43.      WORD_LIST *list;
  44. {
  45.   WORD_LIST *new_list = NULL;
  46.  
  47.   while (list) {
  48.     WORD_LIST *temp = (WORD_LIST *)xmalloc (sizeof (WORD_LIST));
  49.     temp->next = new_list;
  50.     new_list = temp;
  51.     new_list->word = copy_word (list->word);
  52.     list = list->next;
  53.   }
  54.   return ((WORD_LIST *)reverse_list (new_list));
  55. }
  56.  
  57. PATTERN_LIST *
  58. copy_case_clause (clause)
  59.      PATTERN_LIST *clause;
  60. {
  61.   PATTERN_LIST *new_clause = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
  62.   new_clause->patterns = copy_word_list (clause->patterns);
  63.   new_clause->action = copy_command (clause->action);
  64.   return (new_clause);
  65. }
  66.  
  67. PATTERN_LIST *
  68. copy_case_clauses (clauses)
  69.      PATTERN_LIST *clauses;
  70. {
  71.   PATTERN_LIST *new_list = (PATTERN_LIST *)NULL;
  72.  
  73.   while (clauses) {
  74.     PATTERN_LIST *new_clause = copy_case_clause (clauses);
  75.     new_clause->next = new_list;
  76.     new_list = new_clause;
  77.     clauses = clauses->next;
  78.   }
  79.   return ((PATTERN_LIST *)reverse_list (new_list));
  80. }
  81.  
  82. /* Copy a single redirect. */
  83. REDIRECT *
  84. copy_redirect (redirect)
  85.      REDIRECT *redirect;
  86. {
  87.   REDIRECT *new_redirect = (REDIRECT *)xmalloc (sizeof (REDIRECT));
  88.   bcopy (redirect, new_redirect, (sizeof (REDIRECT)));
  89.   switch (redirect->instruction)
  90.     {
  91.     case r_reading_until:
  92.     case r_deblank_reading_until:
  93.       new_redirect->here_doc_eof = savestring (redirect->here_doc_eof);
  94.       /* There is NO BREAK HERE ON PURPOSE!!!! */
  95.     case r_appending_to:
  96.     case r_output_direction:
  97.     case r_input_direction:
  98.     case r_inputa_direction:
  99.     case r_err_and_out:
  100.       new_redirect->redirectee.filename =
  101.     copy_word (redirect->redirectee.filename);
  102.       break;
  103.     }
  104.   return (new_redirect);
  105. }
  106.   
  107. REDIRECT *
  108. copy_redirects (list)
  109.      REDIRECT *list;
  110. {
  111.   REDIRECT *new_list = NULL;
  112.  
  113.   while (list) {
  114.     REDIRECT *temp = copy_redirect (list);
  115.     temp->next = new_list;
  116.     new_list = temp;
  117.     list = list->next;
  118.   }
  119.   return ((REDIRECT *)reverse_list (new_list));
  120. }
  121.   
  122. FOR_COM *
  123. copy_for_command (com)
  124.      FOR_COM *com;
  125. {
  126.   FOR_COM *new_for = (FOR_COM *)xmalloc (sizeof (FOR_COM));
  127.   new_for->name = copy_word (com->name);
  128.   new_for->map_list = copy_word_list (com->map_list);
  129.   new_for->action = copy_command (com->action);
  130.   return (new_for);
  131. }
  132.  
  133. GROUP_COM *
  134. copy_group_command (com)
  135.      GROUP_COM *com;
  136. {
  137.   GROUP_COM *new_group = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
  138.  
  139.   new_group->command = copy_command (com->command);
  140.   return (new_group);
  141. }
  142.  
  143. CASE_COM *
  144. copy_case_command (com)
  145.      CASE_COM *com;
  146. {
  147.   CASE_COM *new_case = (CASE_COM *)xmalloc (sizeof (CASE_COM));
  148.   new_case->word = copy_word (com->word);
  149.   new_case->clauses = copy_case_clauses (com->clauses);
  150.   return (new_case);
  151. }
  152.  
  153. WHILE_COM *
  154. copy_while_command (com)
  155.      WHILE_COM *com;
  156. {
  157.   WHILE_COM *new_while = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
  158.   new_while->test = copy_command (com->test);
  159.   new_while->action = copy_command (com->action);
  160.   return (new_while);
  161. }
  162.  
  163. IF_COM *
  164. copy_if_command (com)
  165.      IF_COM *com;
  166. {
  167.   IF_COM *new_if = (IF_COM *)xmalloc (sizeof (IF_COM));
  168.   new_if->test = copy_command (com->test);
  169.   new_if->true_case = copy_command (com->true_case);
  170.   new_if->false_case = copy_command (com->false_case);
  171.   return (new_if);
  172. }
  173.  
  174. SIMPLE_COM *
  175. copy_simple_command (com)
  176.      SIMPLE_COM *com;
  177. {
  178.   SIMPLE_COM *new_simple = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
  179.   new_simple->words = copy_word_list (com->words);
  180.   new_simple->redirects = copy_redirects (com->redirects);
  181.   return (new_simple);
  182. }
  183.   
  184. FUNCTION_DEF *
  185. copy_function_def (com)
  186.      FUNCTION_DEF *com;
  187. {
  188.   FUNCTION_DEF *new_def = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
  189.   new_def->name = copy_word (com->name);
  190.   new_def->command = copy_command (com->command);
  191.   return (new_def);
  192. }
  193.  
  194. /* Copy the command structure in COMMAND.  Return a pointer to the
  195.    copy.  Don't you forget to dispose_command () on this pointer
  196.    later! */
  197. COMMAND *
  198. copy_command (command)
  199.      COMMAND *command;
  200. {
  201.   if (!command) return ((COMMAND *)NULL);
  202.   {
  203.     COMMAND *new_command = (COMMAND *)xmalloc (sizeof (COMMAND));
  204.     bcopy (command, new_command, sizeof (COMMAND));
  205.  
  206.     if (command->redirects)
  207.       new_command->redirects = copy_redirects (command->redirects);
  208.  
  209.     switch (command->type) {
  210.  
  211.     case cm_for:
  212.       new_command->value.For = copy_for_command (command->value.For);
  213.       break;
  214.  
  215.     case cm_group:
  216.       new_command->value.Group = copy_group_command (command->value.Group);
  217.       break;
  218.  
  219.     case cm_case:
  220.       new_command->value.Case = copy_case_command (command->value.Case);
  221.       break;
  222.       
  223.     case cm_until:
  224.     case cm_while:
  225.       new_command->value.While = copy_while_command (command->value.While);
  226.       break;
  227.       
  228.     case cm_if:
  229.       new_command->value.If = copy_if_command (command->value.If);
  230.       break;
  231.       
  232.     case cm_simple:
  233.       new_command->value.Simple = copy_simple_command (command->value.Simple);
  234.       break;
  235.       
  236.     case cm_connection:
  237.       {
  238.     CONNECTION *new_connection = (CONNECTION *)xmalloc (sizeof (CONNECTION));
  239.     new_connection->connector = command->value.Connection->connector;
  240.     new_connection->first = copy_command (command->value.Connection->first);
  241.     new_connection->second = copy_command (command->value.Connection->second);
  242.     new_command->value.Connection = new_connection;
  243.     break;
  244.       }
  245.       
  246.       /* Pathological case.  I'm not even sure that you can have a
  247.      function definition as part of a function definition. */
  248.     case cm_function_def:
  249.       new_command->value.Function_def = copy_function_def (command->value.Function_def);
  250.       break;
  251.     }
  252.   return (new_command);
  253.   }
  254. }
  255.  
  256.